< Summary

Class:GDX.Tables.StableTable
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs
Covered lines:0
Uncovered lines:1213
Coverable lines:1213
Total lines:1876
Line coverage:0% (0 of 1213)
Covered branches:0
Total branches:0
Covered methods:0
Total methods:170
Method coverage:0% (0 of 170)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
StableTable()0%2100%
StableTable()0%2100%
GetDataVersion()0%2100%
GetColumnCount()0%2100%
GetRowCount()0%2100%
GetDisplayName()0%2100%
SetDisplayName(...)0%2100%
GetFlag(...)0%2100%
SetFlag(...)0%2100%
GetAllRowDescriptions()0%20400%
GetRowDescription(...)0%12300%
GetRowDescription(...)0%2100%
SetAllRowDescriptionsOrder(...)0%2100%
GetColumnDescription(...)0%30500%
GetColumnDescription(...)0%2100%
SetAllColumnDescriptionsOrder(...)0%2100%
GetAllColumnDescriptions()0%12300%
AssertColumnIDValid(...)0%20400%
AssertRowIDValid(...)0%30500%
SetColumnName(...)0%2100%
GetColumnName(...)0%2100%
SetRowName(...)0%2100%
GetRowName(...)0%2100%
GetRowNameRef(...)0%2100%
GetColumnNameRef(...)0%2100%
AddRow(...)0%2401500%
AddRows(...)0%4202000%
AddRows(...)0%4202000%
RemoveRow(...)0%6200%
AddColumn(...)0%9923100%
RemoveColumn(...)0%9303000%
SetString(...)0%2100%
SetBool(...)0%2100%
SetChar(...)0%2100%
SetSByte(...)0%2100%
SetByte(...)0%2100%
SetShort(...)0%2100%
SetUShort(...)0%2100%
SetInt(...)0%2100%
SetUInt(...)0%2100%
SetLong(...)0%2100%
SetULong(...)0%2100%
SetFloat(...)0%2100%
SetDouble(...)0%2100%
SetVector2(...)0%2100%
SetVector3(...)0%2100%
SetVector4(...)0%2100%
SetVector2Int(...)0%2100%
SetVector3Int(...)0%2100%
SetQuaternion(...)0%2100%
SetRect(...)0%2100%
SetRectInt(...)0%2100%
SetColor(...)0%2100%
SetLayerMask(...)0%2100%
SetBounds(...)0%2100%
SetBoundsInt(...)0%2100%
SetHash128(...)0%2100%
SetGradient(...)0%2100%
SetAnimationCurve(...)0%2100%
SetObject(...)0%2100%
SetTypeNameForObjectColumn(...)0%2100%
GetTypeNameForObjectColumn(...)0%2100%
GetString(...)0%2100%
GetBool(...)0%2100%
GetChar(...)0%2100%
GetSByte(...)0%2100%
GetByte(...)0%2100%
GetShort(...)0%2100%
GetUShort(...)0%2100%
GetInt(...)0%2100%
GetUInt(...)0%2100%
GetLong(...)0%2100%
GetULong(...)0%2100%
GetFloat(...)0%2100%
GetDouble(...)0%2100%
GetVector2(...)0%2100%
GetVector3(...)0%2100%
GetVector4(...)0%2100%
GetVector2Int(...)0%2100%
GetVector3Int(...)0%2100%
GetQuaternion(...)0%2100%
GetRect(...)0%2100%
GetRectInt(...)0%2100%
GetColor(...)0%2100%
GetLayerMask(...)0%2100%
GetBounds(...)0%2100%
GetBoundsInt(...)0%2100%
GetHash128(...)0%2100%
GetGradient(...)0%2100%
GetAnimationCurve(...)0%2100%
GetObject(...)0%2100%
GetStringRef(...)0%2100%
GetBoolRef(...)0%2100%
GetCharRef(...)0%2100%
GetSbyteRef(...)0%2100%
GetByteRef(...)0%2100%
GetShortRef(...)0%2100%
GetUshortRef(...)0%2100%
GetIntRef(...)0%2100%
GetUintRef(...)0%2100%
GetLongRef(...)0%2100%
GetUlongRef(...)0%2100%
GetFloatRef(...)0%2100%
GetDoubleRef(...)0%2100%
GetVector2Ref(...)0%2100%
GetVector3Ref(...)0%2100%
GetVector4Ref(...)0%2100%
GetVector2IntRef(...)0%2100%
GetVector3IntRef(...)0%2100%
GetQuaternionRef(...)0%2100%
GetRectRef(...)0%2100%
GetRectIntRef(...)0%2100%
GetColorRef(...)0%2100%
GetLayerMaskRef(...)0%2100%
GetBoundsRef(...)0%2100%
GetBoundsIntRef(...)0%2100%
GetHash128Ref(...)0%2100%
GetGradientRef(...)0%2100%
GetAnimationCurveRef(...)0%2100%
GetObjectRef(...)0%2100%
GetStringColumn(...)0%2100%
GetBoolColumn(...)0%2100%
GetCharColumn(...)0%2100%
GetSbyteColumn(...)0%2100%
GetByteColumn(...)0%2100%
GetShortColumn(...)0%2100%
GetUshortColumn(...)0%2100%
GetIntColumn(...)0%2100%
GetUintColumn(...)0%2100%
GetLongColumn(...)0%2100%
GetUlongColumn(...)0%2100%
GetFloatColumn(...)0%2100%
GetDoubleColumn(...)0%2100%
GetVector2Column(...)0%2100%
GetVector3Column(...)0%2100%
GetVector4Column(...)0%2100%
GetVector2IntColumn(...)0%2100%
GetVector3IntColumn(...)0%2100%
GetQuaternionColumn(...)0%2100%
GetRectColumn(...)0%2100%
GetRectIntColumn(...)0%2100%
GetColorColumn(...)0%2100%
GetLayerMaskColumn(...)0%2100%
GetBoundsColumn(...)0%2100%
GetBoundsIntColumn(...)0%2100%
GetHash128Column(...)0%2100%
GetGradientColumn(...)0%2100%
GetAnimationCurveColumn(...)0%2100%
GetObjectColumn(...)0%2100%
SetColumnOrder(...)0%20400%
SetAllColumnOrders(...)0%6200%
SetRowOrder(...)0%20400%
SetAllRowOrders(...)0%6200%
ReSortRows[T](...)0%30500%
AddTypeNameEntryForUnityObjectColumn()0%12300%
RemoveTypeNameEntryForUnityObjectColumn(...)0%12300%
AssertObjectColumnIDValid(...)0%6200%
AddColumnInternal[T](...)0%4622100%
RemoveColumnInternal[T](...)0%12300%
InsertRowsOfTypeInternal[T](...)0%42600%
DeleteRowsOfTypeInternal[T](...)0%30500%
GetCellRef[T](...)0%2100%
GetCell[T](...)0%2100%
SetCell[T](...)0%2100%
GetColumn[T](...)0%2100%
SetRowOrderForColumns[T](...)0%56700%
AssertSortedColumnsArgValid(...)0%20400%
AssertColumnSortOrderValid(...)0%12300%
AssertRowSortOrderValid(...)0%12300%
AssertSortRowsArgValid(...)0%20400%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Tables/StableTable.cs

#LineLine coverage
 1// Copyright (c) 2020-2023 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System;
 6using GDX.Collections;
 7using UnityEngine;
 8using Object = UnityEngine.Object;
 9
 10namespace GDX.Tables
 11{
 12    [CreateAssetMenu(menuName = "GDX/Stable Table", fileName = "GDXStableTable")]
 13    [Serializable]
 14    public class StableTable : TableBase
 15    {
 016        internal static string UnityObjectString = typeof(Object).AssemblyQualifiedName;
 17
 018        [SerializeField] internal string DisplayName = "GDXStableTable";
 19
 20        [SerializeField] internal ArrayHolder<string>[] AllStringColumns;
 21        [SerializeField] internal ArrayHolder<bool>[] AllBoolColumns;
 22        [SerializeField] internal ArrayHolder<char>[] AllCharColumns;
 23        [SerializeField] internal ArrayHolder<sbyte>[] AllSbyteColumns;
 24        [SerializeField] internal ArrayHolder<byte>[] AllByteColumns;
 25        [SerializeField] internal ArrayHolder<short>[] AllShortColumns;
 26        [SerializeField] internal ArrayHolder<ushort>[] AllUshortColumns;
 27        [SerializeField] internal ArrayHolder<int>[] AllIntColumns;
 28        [SerializeField] internal ArrayHolder<uint>[] AllUintColumns;
 29        [SerializeField] internal ArrayHolder<long>[] AllLongColumns;
 30        [SerializeField] internal ArrayHolder<ulong>[] AllUlongColumns;
 31        [SerializeField] internal ArrayHolder<float>[] AllFloatColumns;
 32        [SerializeField] internal ArrayHolder<double>[] AllDoubleColumns;
 33        [SerializeField] internal ArrayHolder<Vector2>[] AllVector2Columns;
 34        [SerializeField] internal ArrayHolder<Vector3>[] AllVector3Columns;
 35        [SerializeField] internal ArrayHolder<Vector4>[] AllVector4Columns;
 36        [SerializeField] internal ArrayHolder<Vector2Int>[] AllVector2IntColumns;
 37        [SerializeField] internal ArrayHolder<Vector3Int>[] AllVector3IntColumns;
 38        [SerializeField] internal ArrayHolder<Quaternion>[] AllQuaternionColumns;
 39        [SerializeField] internal ArrayHolder<Rect>[] AllRectColumns;
 40        [SerializeField] internal ArrayHolder<RectInt>[] AllRectIntColumns;
 41        [SerializeField] internal ArrayHolder<Color>[] AllColorColumns;
 42        [SerializeField] internal ArrayHolder<LayerMask>[] AllLayerMaskColumns;
 43        [SerializeField] internal ArrayHolder<Bounds>[] AllBoundsColumns;
 44        [SerializeField] internal ArrayHolder<BoundsInt>[] AllBoundsIntColumns;
 45        [SerializeField] internal ArrayHolder<Hash128>[] AllHash128Columns;
 46        [SerializeField] internal ArrayHolder<Gradient>[] AllGradientColumns;
 47        [SerializeField] internal ArrayHolder<AnimationCurve>[] AllAnimationCurveColumns;
 48        [SerializeField] internal ArrayHolder<Object>[] AllObjectRefColumns;
 49        [SerializeField] internal string[] AllObjectRefTypeNames;
 50
 51        [SerializeField]
 052        internal ArrayHolder<string>[]
 53            AllColumnNames =
 54                new ArrayHolder<string>[Serializable
 55                    .SerializableTypesCount]; // Contains the name of each column of each type. Ordered by Serializable.
 56
 57        [SerializeField] internal int[] RowIDToDenseIndexMap;
 58        [SerializeField] internal int[] RowDenseIndexToIDMap;
 59        [SerializeField] internal string[] RowNames;
 60        [SerializeField] internal int RowEntriesFreeListHead;
 61
 62        [SerializeField] internal int RowCount;
 63
 64        [SerializeField] internal ColumnEntry[] ColumnIDToDenseIndexMap;
 65        [SerializeField] internal int[] ColumnIDToSortOrderMap;
 66        [SerializeField] internal int[] SortedOrderToColumnIDMap;
 67
 68        // TODO move with other block
 69        [SerializeField]
 070        ArrayHolder<int>[] ColumnDenseIndexToIDMap = new ArrayHolder<int>[Serializable.SerializableTypesCount];
 71
 72        [SerializeField] internal int ColumnEntriesFreeListHead;
 73
 74        [SerializeField] internal int CombinedColumnCount;
 75
 076        [SerializeField] internal ulong DataVersion = 1;
 77
 78        [SerializeField] BitArray8 SettingsFlags;
 79
 80        public override ulong GetDataVersion()
 081        {
 082            return DataVersion;
 083        }
 84
 85        /// <inheritdoc />
 86        public override int GetColumnCount()
 087        {
 088            return CombinedColumnCount;
 089        }
 90
 91        /// <inheritdoc />
 92        public override int GetRowCount()
 093        {
 094            return RowCount;
 095        }
 96
 97        public override string GetDisplayName()
 098        {
 099            return DisplayName;
 0100        }
 101
 102        public override void SetDisplayName(string displayName)
 0103        {
 0104            DisplayName = displayName;
 0105        }
 106
 107        public override bool GetFlag(Flags flag)
 0108        {
 0109            return SettingsFlags[(byte)flag];
 0110        }
 111
 112        public override void SetFlag(Flags flag, bool toggle)
 0113        {
 0114            SettingsFlags[(byte)flag] = toggle;
 0115        }
 116
 117        public override RowDescription[] GetAllRowDescriptions()
 0118        {
 0119            if (CombinedColumnCount == 0 || RowCount == 0)
 0120            {
 0121                return null;
 122            }
 123
 0124            RowDescription[] returnArray = new RowDescription[RowCount];
 0125            for (int i = 0; i < RowCount; i++)
 0126            {
 0127                returnArray[i].InternalIndex = RowDenseIndexToIDMap[i];
 0128                returnArray[i].Name = RowNames[i];
 0129            }
 130
 0131            return returnArray;
 0132        }
 133
 134        public override RowDescription GetRowDescription(string name)
 0135        {
 0136            for (int i = 0; i < RowCount; i++)
 0137            {
 0138                string nameAt = RowNames[i];
 139
 0140                if (nameAt == name)
 0141                {
 0142                    return new RowDescription { InternalIndex = RowDenseIndexToIDMap[i], Name = nameAt };
 143                }
 0144            }
 145
 0146            throw new ArgumentException("Row with name " + name + " does not exist in the table");
 0147        }
 148
 149        public override RowDescription GetRowDescription(int order)
 0150        {
 0151            return new RowDescription { InternalIndex = RowDenseIndexToIDMap[order], Name = RowNames[order] };
 0152        }
 153
 154        public override void SetAllRowDescriptionsOrder(RowDescription[] orderedRows)
 0155        {
 156            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0157            throw new NotImplementedException();
 158        }
 159
 160        public override ColumnDescription GetColumnDescription(string name)
 0161        {
 0162            for (int i = 0; i < Serializable.SerializableTypesCount; i++)
 0163            {
 0164                string[] columnNames = AllColumnNames[i].TArray;
 165
 0166                if (columnNames != null)
 0167                {
 0168                    for (int j = 0; j < columnNames.Length; j++)
 0169                    {
 0170                        string nameAt = columnNames[j];
 171
 0172                        if (name == nameAt)
 0173                        {
 0174                            int columnID = ColumnDenseIndexToIDMap[i].TArray[j];
 175
 0176                            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 0177                            return new ColumnDescription
 178                            {
 179                                InternalIndex = columnID, Name = nameAt, Type = columnEntry.ColumnType
 180                            };
 181                        }
 0182                    }
 0183                }
 0184            }
 185
 0186            throw new ArgumentException("Column with name " + name + " does not exist in the table");
 0187        }
 188
 189        public override ColumnDescription GetColumnDescription(int order)
 0190        {
 0191            int idAtOrderedIndex = SortedOrderToColumnIDMap[order];
 0192            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[idAtOrderedIndex];
 193
 0194            string columnName = AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 195
 0196            return new ColumnDescription
 197            {
 198                InternalIndex = idAtOrderedIndex, Name = columnName, Type = columnEntry.ColumnType
 199            };
 0200        }
 201
 202        public override void SetAllColumnDescriptionsOrder(ColumnDescription[] orderedColumns)
 0203        {
 204            // TODO: @adam array coming in be in the new order, just use the internalIndex (stable to reorder inside her
 0205            throw new NotImplementedException();
 206        }
 207
 208        /// <inheritdoc />
 209        public override ColumnDescription[] GetAllColumnDescriptions()
 0210        {
 0211            if (CombinedColumnCount == 0)
 0212            {
 0213                return null;
 214            }
 215
 0216            ColumnDescription[] returnArray = new ColumnDescription[CombinedColumnCount];
 217
 0218            for (int i = 0; i < CombinedColumnCount; i++)
 0219            {
 0220                int columnID = SortedOrderToColumnIDMap[i];
 0221                AssertColumnIDValid(columnID);
 0222                ref ColumnEntry entryForID = ref ColumnIDToDenseIndexMap[columnID];
 0223                ref ArrayHolder<string> nameColumnsForType = ref AllColumnNames[(int)entryForID.ColumnType];
 224
 0225                string name = nameColumnsForType[entryForID.ColumnDenseIndex];
 226
 0227                returnArray[i] = new ColumnDescription
 228                {
 229                    Name = name, InternalIndex = columnID, Type = entryForID.ColumnType
 230                };
 0231            }
 232
 0233            return returnArray;
 0234        }
 235
 236        internal void AssertColumnIDValid(int columnID)
 0237        {
 0238            if (columnID < 0 || columnID >= ColumnIDToDenseIndexMap.Length)
 0239            {
 0240                throw new ArgumentException("Invalid column outside valid ID range: " + columnID);
 241            }
 242
 0243            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 244
 0245            if (columnEntry.ColumnType == Serializable.SerializableTypes.Invalid)
 0246            {
 0247                throw new ArgumentException("Invalid column pointing to deallocated entry: " + columnID);
 248            }
 0249        }
 250
 251        internal void AssertRowIDValid(int rowID)
 0252        {
 0253            if (rowID < 0 || rowID >= RowIDToDenseIndexMap.Length)
 0254            {
 0255                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 256            }
 257
 0258            int rowIndex = RowIDToDenseIndexMap[rowID];
 259
 0260            if (rowIndex >= RowCount || rowIndex < 0)
 0261            {
 0262                throw new ArgumentException("Invalid row outside valid ID range: " + rowID);
 263            }
 0264        }
 265
 266        public override void SetColumnName(string columnName, int column)
 0267        {
 0268            AssertColumnIDValid(column);
 0269            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[column];
 0270            AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex] = columnName;
 0271        }
 272
 273        public override string GetColumnName(int column)
 0274        {
 0275            AssertColumnIDValid(column);
 0276            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[column];
 0277            return AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 0278        }
 279
 280
 281
 282        public override void SetRowName(string rowName, int row)
 0283        {
 0284            AssertRowIDValid(row);
 0285            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0286            RowNames[rowDenseIndex] = rowName;
 0287        }
 288
 289        public override string GetRowName(int row)
 0290        {
 0291            AssertRowIDValid(row);
 0292            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0293            return RowNames[rowDenseIndex];
 0294        }
 295
 296        public ref string GetRowNameRef(int row)
 0297        {
 0298            AssertRowIDValid(row);
 0299            int rowDenseIndex = RowIDToDenseIndexMap[row];
 0300            return ref RowNames[rowDenseIndex];
 0301        }
 302
 303        public ref string GetColumnNameRef(int columnID)
 0304        {
 0305            AssertColumnIDValid(columnID);
 0306            ref ColumnEntry columnEntry = ref ColumnIDToDenseIndexMap[columnID];
 0307            return ref AllColumnNames[(int)columnEntry.ColumnType][columnEntry.ColumnDenseIndex];
 0308        }
 309
 310
 311        public override int AddRow(string rowName = null, int insertAtRowID = -1)
 0312        {
 0313            if (insertAtRowID >= 0)
 0314            {
 0315                AssertRowIDValid(insertAtRowID);
 0316            }
 317
 0318            int rowID = RowEntriesFreeListHead;
 0319            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0320            if (rowID >= rowIDToDenseIndexMapLength)
 0321            {
 0322                int newSize = rowID * 2;
 0323                newSize = newSize == 0 ? 1 : newSize;
 0324                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0325                for (int i = rowID; i < newSize; i++)
 0326                {
 0327                    RowIDToDenseIndexMap[i] = i + 1;
 0328                }
 0329            }
 330
 0331            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0332            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + 1);
 0333            Array.Resize(ref RowNames, denseIndexToIDMapLength + 1);
 334
 0335            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 336
 0337            for (int i = denseIndexToIDMapLength; i > insertAt; i--)
 0338            {
 0339                int currentRowID = RowDenseIndexToIDMap[i - 1];
 0340                RowDenseIndexToIDMap[i] = currentRowID;
 341
 0342                RowIDToDenseIndexMap[currentRowID] = i;
 343
 0344                RowNames[i] = RowNames[i - 1];
 0345            }
 346
 0347            RowEntriesFreeListHead = RowIDToDenseIndexMap[rowID];
 0348            RowIDToDenseIndexMap[rowID] = insertAt;
 0349            RowDenseIndexToIDMap[insertAt] = rowID;
 0350            RowNames[insertAt] = rowName == null ? rowID.ToString() : rowName;
 351
 0352            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, 1);
 0353            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, 1);
 0354            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, 1);
 0355            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, 1);
 0356            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, 1);
 0357            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, 1);
 0358            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, 1);
 0359            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, 1);
 0360            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, 1);
 0361            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, 1);
 0362            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, 1);
 0363            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, 1);
 0364            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, 1);
 0365            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, 1);
 0366            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, 1);
 0367            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, 1);
 0368            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, 1);
 0369            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, 1);
 0370            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, 1);
 0371            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, 1);
 0372            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, 1);
 0373            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, 1);
 0374            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, 1);
 0375            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, 1);
 0376            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, 1);
 0377            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, 1);
 0378            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, 1);
 0379            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, 1);
 0380            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, 1);
 381
 0382            ++RowCount;
 0383            DataVersion++;
 384
 0385            return rowID;
 0386        }
 387
 388        public void AddRows(int numberOfNewRows, string[] rowNames = null, int insertAtRowID = -1)
 0389        {
 0390            if (insertAtRowID >= 0)
 0391            {
 0392                AssertRowIDValid(insertAtRowID);
 0393            }
 394
 0395            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0396            int newCount = RowCount + numberOfNewRows;
 0397            if (newCount > rowIDToDenseIndexMapLength)
 0398            {
 0399                int newSize = newCount;
 0400                --newSize;
 0401                newSize |= newSize >> 1;
 0402                newSize |= newSize >> 2;
 0403                newSize |= newSize >> 4;
 0404                newSize |= newSize >> 8;
 0405                newSize |= newSize >> 16;
 0406                ++newSize;
 407
 0408                newSize = newSize == 0 ? 1 : newSize;
 0409                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0410                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0411                {
 0412                    RowIDToDenseIndexMap[i] = i + 1;
 0413                }
 0414            }
 415
 0416            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0417            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 0418            Array.Resize(ref rowNames, denseIndexToIDMapLength + numberOfNewRows);
 419
 0420            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 421
 0422            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0423            {
 0424                int currentRowID = RowDenseIndexToIDMap[i - numberOfNewRows];
 0425                RowDenseIndexToIDMap[i] = currentRowID;
 426
 0427                RowIDToDenseIndexMap[currentRowID] = i;
 428
 0429                rowNames[i] = rowNames[i - numberOfNewRows];
 0430            }
 431
 0432            int freeListHead = RowEntriesFreeListHead;
 433
 0434            for (int i = 0; i < numberOfNewRows; i++)
 0435            {
 0436                int rowID = freeListHead;
 0437                freeListHead = RowIDToDenseIndexMap[rowID];
 0438                RowIDToDenseIndexMap[rowID] = insertAt + i;
 0439                RowDenseIndexToIDMap[insertAt + i] = rowID;
 0440            }
 441
 0442            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0443            string emptyString = string.Empty;
 0444            for (int i = 0; i < numberOfNewRowNames; i++)
 0445            {
 0446                string currentRowName = rowNames[i];
 0447                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0448                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0449            }
 450
 0451            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0452            {
 0453                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0454                rowNames[insertAt + i] = rowIDAt.ToString();
 0455            }
 456
 0457            RowEntriesFreeListHead = freeListHead;
 458
 0459            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, numberOfNewRows);
 0460            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, numberOfNewRows);
 0461            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, numberOfNewRows);
 0462            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, numberOfNewRows);
 0463            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, numberOfNewRows);
 0464            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, numberOfNewRows);
 0465            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, numberOfNewRows);
 0466            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, numberOfNewRows);
 0467            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, numberOfNewRows);
 0468            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, numberOfNewRows);
 0469            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, numberOfNewRows);
 0470            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, numberOfNewRows);
 0471            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, numberOfNewRows);
 0472            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, numberOfNewRows);
 0473            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, numberOfNewRows);
 0474            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, numberOfNewRows);
 0475            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, numberOfNewRows);
 0476            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, numberOfNewRows);
 0477            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, numberOfNewRows);
 0478            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, numberOfNewRows);
 0479            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, numberOfNewRows);
 0480            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, numberOfNewRows);
 0481            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, numberOfNewRows);
 0482            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, numberOfNewRows);
 0483            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, numberOfNewRows);
 0484            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, numberOfNewRows);
 0485            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, numberOfNewRows);
 0486            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0487            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, numberOfNewRows);
 488
 0489            RowCount += numberOfNewRows;
 0490            DataVersion++;
 0491        }
 492
 493        public void AddRows(int numberOfNewRows, ref int[] rowIDs, string[] rowNames = null, int insertAtRowID = -1)
 0494        {
 0495            if (insertAtRowID >= 0)
 0496            {
 0497                AssertRowIDValid(insertAtRowID);
 0498            }
 499
 0500            int rowIDToDenseIndexMapLength = RowIDToDenseIndexMap?.Length ?? 0;
 0501            int newCount = RowCount + numberOfNewRows;
 0502            if (newCount > rowIDToDenseIndexMapLength)
 0503            {
 0504                int newSize = newCount;
 0505                --newSize;
 0506                newSize |= newSize >> 1;
 0507                newSize |= newSize >> 2;
 0508                newSize |= newSize >> 4;
 0509                newSize |= newSize >> 8;
 0510                newSize |= newSize >> 16;
 0511                ++newSize;
 512
 0513                newSize = newSize == 0 ? 1 : newSize;
 0514                Array.Resize(ref RowIDToDenseIndexMap, newSize);
 0515                for (int i = rowIDToDenseIndexMapLength; i < newSize; i++)
 0516                {
 0517                    RowIDToDenseIndexMap[i] = i + 1;
 0518                }
 0519            }
 520
 0521            int denseIndexToIDMapLength = RowDenseIndexToIDMap?.Length ?? 0;
 0522            Array.Resize(ref RowDenseIndexToIDMap, denseIndexToIDMapLength + numberOfNewRows);
 523
 0524            int insertAt = insertAtRowID < 0 ? RowCount : RowIDToDenseIndexMap[insertAtRowID];
 525
 0526            for (int i = denseIndexToIDMapLength; i > insertAt + numberOfNewRows - 1; i--)
 0527            {
 0528                int currentRowID = RowDenseIndexToIDMap[i - numberOfNewRows];
 0529                RowDenseIndexToIDMap[i] = currentRowID;
 530
 0531                RowIDToDenseIndexMap[currentRowID] = i;
 532
 0533                rowNames[i] = rowNames[i - numberOfNewRows];
 0534            }
 535
 0536            int freeListHead = RowEntriesFreeListHead;
 537
 0538            for (int i = 0; i < numberOfNewRows; i++)
 0539            {
 0540                int rowID = freeListHead;
 0541                freeListHead = RowIDToDenseIndexMap[rowID];
 0542                RowIDToDenseIndexMap[rowID] = insertAt + i;
 0543                RowDenseIndexToIDMap[insertAt + i] = rowID;
 0544                rowIDs[i] = rowID;
 0545            }
 546
 0547            int numberOfNewRowNames = rowNames?.Length ?? 0;
 0548            for (int i = 0; i < numberOfNewRowNames; i++)
 0549            {
 0550                string currentRowName = rowNames[i];
 0551                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0552                rowNames[insertAt + i] = currentRowName == null ? rowIDAt.ToString() : currentRowName;
 0553            }
 554
 0555            for (int i = numberOfNewRowNames; i < numberOfNewRows; i++)
 0556            {
 0557                int rowIDAt = RowDenseIndexToIDMap[insertAt + i];
 0558                rowNames[insertAt + i] = rowIDAt.ToString();
 0559            }
 560
 0561            RowEntriesFreeListHead = freeListHead;
 562
 0563            InsertRowsOfTypeInternal(ref AllStringColumns, insertAt, numberOfNewRows);
 0564            InsertRowsOfTypeInternal(ref AllBoolColumns, insertAt, numberOfNewRows);
 0565            InsertRowsOfTypeInternal(ref AllCharColumns, insertAt, numberOfNewRows);
 0566            InsertRowsOfTypeInternal(ref AllSbyteColumns, insertAt, numberOfNewRows);
 0567            InsertRowsOfTypeInternal(ref AllByteColumns, insertAt, numberOfNewRows);
 0568            InsertRowsOfTypeInternal(ref AllShortColumns, insertAt, numberOfNewRows);
 0569            InsertRowsOfTypeInternal(ref AllUshortColumns, insertAt, numberOfNewRows);
 0570            InsertRowsOfTypeInternal(ref AllIntColumns, insertAt, numberOfNewRows);
 0571            InsertRowsOfTypeInternal(ref AllUintColumns, insertAt, numberOfNewRows);
 0572            InsertRowsOfTypeInternal(ref AllLongColumns, insertAt, numberOfNewRows);
 0573            InsertRowsOfTypeInternal(ref AllUlongColumns, insertAt, numberOfNewRows);
 0574            InsertRowsOfTypeInternal(ref AllFloatColumns, insertAt, numberOfNewRows);
 0575            InsertRowsOfTypeInternal(ref AllDoubleColumns, insertAt, numberOfNewRows);
 0576            InsertRowsOfTypeInternal(ref AllVector2Columns, insertAt, numberOfNewRows);
 0577            InsertRowsOfTypeInternal(ref AllVector3Columns, insertAt, numberOfNewRows);
 0578            InsertRowsOfTypeInternal(ref AllVector4Columns, insertAt, numberOfNewRows);
 0579            InsertRowsOfTypeInternal(ref AllVector2IntColumns, insertAt, numberOfNewRows);
 0580            InsertRowsOfTypeInternal(ref AllVector3IntColumns, insertAt, numberOfNewRows);
 0581            InsertRowsOfTypeInternal(ref AllQuaternionColumns, insertAt, numberOfNewRows);
 0582            InsertRowsOfTypeInternal(ref AllRectColumns, insertAt, numberOfNewRows);
 0583            InsertRowsOfTypeInternal(ref AllRectIntColumns, insertAt, numberOfNewRows);
 0584            InsertRowsOfTypeInternal(ref AllColorColumns, insertAt, numberOfNewRows);
 0585            InsertRowsOfTypeInternal(ref AllLayerMaskColumns, insertAt, numberOfNewRows);
 0586            InsertRowsOfTypeInternal(ref AllBoundsColumns, insertAt, numberOfNewRows);
 0587            InsertRowsOfTypeInternal(ref AllBoundsIntColumns, insertAt, numberOfNewRows);
 0588            InsertRowsOfTypeInternal(ref AllHash128Columns, insertAt, numberOfNewRows);
 0589            InsertRowsOfTypeInternal(ref AllGradientColumns, insertAt, numberOfNewRows);
 0590            InsertRowsOfTypeInternal(ref AllAnimationCurveColumns, insertAt, numberOfNewRows);
 0591            InsertRowsOfTypeInternal(ref AllObjectRefColumns, insertAt, numberOfNewRows);
 592
 0593            RowCount += numberOfNewRows;
 0594            DataVersion++;
 0595        }
 596
 597        public override void RemoveRow(int rowID)
 0598        {
 0599            AssertRowIDValid(rowID);
 0600            int rowDenseIndex = RowIDToDenseIndexMap[rowID];
 0601            for (int i = rowDenseIndex + 1; i < RowCount; i++)
 0602            {
 0603                int currentRowID = RowDenseIndexToIDMap[i];
 0604                RowIDToDenseIndexMap[currentRowID] = i - 1;
 0605                RowDenseIndexToIDMap[i - 1] = currentRowID;
 0606                RowNames[i - 1] = RowNames[i];
 0607            }
 608
 0609            RowIDToDenseIndexMap[rowID] = RowEntriesFreeListHead;
 0610            RowEntriesFreeListHead = rowID;
 0611            Array.Resize(ref RowDenseIndexToIDMap, RowCount - 1);
 0612            Array.Resize(ref RowNames, RowCount - 1);
 613
 0614            DeleteRowsOfTypeInternal(ref AllStringColumns, rowID, 1);
 0615            DeleteRowsOfTypeInternal(ref AllBoolColumns, rowID, 1);
 0616            DeleteRowsOfTypeInternal(ref AllCharColumns, rowID, 1);
 0617            DeleteRowsOfTypeInternal(ref AllSbyteColumns, rowID, 1);
 0618            DeleteRowsOfTypeInternal(ref AllByteColumns, rowID, 1);
 0619            DeleteRowsOfTypeInternal(ref AllShortColumns, rowID, 1);
 0620            DeleteRowsOfTypeInternal(ref AllUshortColumns, rowID, 1);
 0621            DeleteRowsOfTypeInternal(ref AllIntColumns, rowID, 1);
 0622            DeleteRowsOfTypeInternal(ref AllUintColumns, rowID, 1);
 0623            DeleteRowsOfTypeInternal(ref AllLongColumns, rowID, 1);
 0624            DeleteRowsOfTypeInternal(ref AllUlongColumns, rowID, 1);
 0625            DeleteRowsOfTypeInternal(ref AllFloatColumns, rowID, 1);
 0626            DeleteRowsOfTypeInternal(ref AllDoubleColumns, rowID, 1);
 0627            DeleteRowsOfTypeInternal(ref AllVector2Columns, rowID, 1);
 0628            DeleteRowsOfTypeInternal(ref AllVector3Columns, rowID, 1);
 0629            DeleteRowsOfTypeInternal(ref AllVector4Columns, rowID, 1);
 0630            DeleteRowsOfTypeInternal(ref AllVector2IntColumns, rowID, 1);
 0631            DeleteRowsOfTypeInternal(ref AllVector3IntColumns, rowID, 1);
 0632            DeleteRowsOfTypeInternal(ref AllQuaternionColumns, rowID, 1);
 0633            DeleteRowsOfTypeInternal(ref AllRectColumns, rowID, 1);
 0634            DeleteRowsOfTypeInternal(ref AllRectIntColumns, rowID, 1);
 0635            DeleteRowsOfTypeInternal(ref AllColorColumns, rowID, 1);
 0636            DeleteRowsOfTypeInternal(ref AllLayerMaskColumns, rowID, 1);
 0637            DeleteRowsOfTypeInternal(ref AllBoundsColumns, rowID, 1);
 0638            DeleteRowsOfTypeInternal(ref AllBoundsIntColumns, rowID, 1);
 0639            DeleteRowsOfTypeInternal(ref AllHash128Columns, rowID, 1);
 0640            DeleteRowsOfTypeInternal(ref AllGradientColumns, rowID, 1);
 0641            DeleteRowsOfTypeInternal(ref AllAnimationCurveColumns, rowID, 1);
 0642            DeleteRowsOfTypeInternal(ref AllObjectRefColumns, rowID, 1);
 643
 0644            --RowCount;
 0645            DataVersion++;
 0646        }
 647
 648        public override int AddColumn(Serializable.SerializableTypes columnType, string columnName,
 649            int insertAtColumnID = -1)
 0650        {
 0651            switch (columnType)
 652            {
 653                case Serializable.SerializableTypes.String:
 0654                    return AddColumnInternal(columnName, ref AllStringColumns, Serializable.SerializableTypes.String,
 655                        insertAtColumnID);
 656                case Serializable.SerializableTypes.Char:
 0657                    return AddColumnInternal(columnName, ref AllCharColumns, Serializable.SerializableTypes.Char,
 658                        insertAtColumnID);
 659                case Serializable.SerializableTypes.Bool:
 0660                    return AddColumnInternal(columnName, ref AllBoolColumns, Serializable.SerializableTypes.Bool,
 661                        insertAtColumnID);
 662                case Serializable.SerializableTypes.SByte:
 0663                    return AddColumnInternal(columnName, ref AllSbyteColumns, Serializable.SerializableTypes.SByte,
 664                        insertAtColumnID);
 665                case Serializable.SerializableTypes.Byte:
 0666                    return AddColumnInternal(columnName, ref AllByteColumns, Serializable.SerializableTypes.Byte,
 667                        insertAtColumnID);
 668                case Serializable.SerializableTypes.Short:
 0669                    return AddColumnInternal(columnName, ref AllShortColumns, Serializable.SerializableTypes.Short,
 670                        insertAtColumnID);
 671                case Serializable.SerializableTypes.UShort:
 0672                    return AddColumnInternal(columnName, ref AllUshortColumns, Serializable.SerializableTypes.UShort,
 673                        insertAtColumnID);
 674                case Serializable.SerializableTypes.Int:
 0675                    return AddColumnInternal(columnName, ref AllIntColumns, Serializable.SerializableTypes.Int,
 676                        insertAtColumnID);
 677                case Serializable.SerializableTypes.UInt:
 0678                    return AddColumnInternal(columnName, ref AllUintColumns, Serializable.SerializableTypes.UInt,
 679                        insertAtColumnID);
 680                case Serializable.SerializableTypes.Long:
 0681                    return AddColumnInternal(columnName, ref AllLongColumns, Serializable.SerializableTypes.Long,
 682                        insertAtColumnID);
 683                case Serializable.SerializableTypes.ULong:
 0684                    return AddColumnInternal(columnName, ref AllUlongColumns, Serializable.SerializableTypes.ULong,
 685                        insertAtColumnID);
 686                case Serializable.SerializableTypes.Float:
 0687                    return AddColumnInternal(columnName, ref AllFloatColumns, Serializable.SerializableTypes.Float,
 688                        insertAtColumnID);
 689                case Serializable.SerializableTypes.Double:
 0690                    return AddColumnInternal(columnName, ref AllDoubleColumns, Serializable.SerializableTypes.Double,
 691                        insertAtColumnID);
 692                case Serializable.SerializableTypes.Vector2:
 0693                    return AddColumnInternal(columnName, ref AllVector2Columns, Serializable.SerializableTypes.Vector2,
 694                        insertAtColumnID);
 695                case Serializable.SerializableTypes.Vector3:
 0696                    return AddColumnInternal(columnName, ref AllVector3Columns, Serializable.SerializableTypes.Vector3,
 697                        insertAtColumnID);
 698                case Serializable.SerializableTypes.Vector4:
 0699                    return AddColumnInternal(columnName, ref AllVector4Columns, Serializable.SerializableTypes.Vector4,
 700                        insertAtColumnID);
 701                case Serializable.SerializableTypes.Vector2Int:
 0702                    return AddColumnInternal(columnName, ref AllVector2IntColumns,
 703                        Serializable.SerializableTypes.Vector2Int, insertAtColumnID);
 704                case Serializable.SerializableTypes.Vector3Int:
 0705                    return AddColumnInternal(columnName, ref AllVector3IntColumns,
 706                        Serializable.SerializableTypes.Vector3Int, insertAtColumnID);
 707                case Serializable.SerializableTypes.Quaternion:
 0708                    return AddColumnInternal(columnName, ref AllQuaternionColumns,
 709                        Serializable.SerializableTypes.Quaternion, insertAtColumnID);
 710                case Serializable.SerializableTypes.Rect:
 0711                    return AddColumnInternal(columnName, ref AllRectColumns, Serializable.SerializableTypes.Rect,
 712                        insertAtColumnID);
 713                case Serializable.SerializableTypes.RectInt:
 0714                    return AddColumnInternal(columnName, ref AllRectIntColumns, Serializable.SerializableTypes.RectInt,
 715                        insertAtColumnID);
 716                case Serializable.SerializableTypes.Color:
 0717                    return AddColumnInternal(columnName, ref AllColorColumns, Serializable.SerializableTypes.Color,
 718                        insertAtColumnID);
 719                case Serializable.SerializableTypes.LayerMask:
 0720                    return AddColumnInternal(columnName, ref AllLayerMaskColumns,
 721                        Serializable.SerializableTypes.LayerMask, insertAtColumnID);
 722                case Serializable.SerializableTypes.Bounds:
 0723                    return AddColumnInternal(columnName, ref AllBoundsColumns, Serializable.SerializableTypes.Bounds,
 724                        insertAtColumnID);
 725                case Serializable.SerializableTypes.BoundsInt:
 0726                    return AddColumnInternal(columnName, ref AllBoundsIntColumns,
 727                        Serializable.SerializableTypes.BoundsInt, insertAtColumnID);
 728                case Serializable.SerializableTypes.Hash128:
 0729                    return AddColumnInternal(columnName, ref AllHash128Columns, Serializable.SerializableTypes.Hash128,
 730                        insertAtColumnID);
 731                case Serializable.SerializableTypes.Gradient:
 0732                    return AddColumnInternal(columnName, ref AllGradientColumns,
 733                        Serializable.SerializableTypes.Gradient, insertAtColumnID);
 734                case Serializable.SerializableTypes.AnimationCurve:
 0735                    return AddColumnInternal(columnName, ref AllAnimationCurveColumns,
 736                        Serializable.SerializableTypes.AnimationCurve, insertAtColumnID);
 737                case Serializable.SerializableTypes.Object:
 0738                    return AddColumnInternal(columnName, ref AllObjectRefColumns, Serializable.SerializableTypes.Object,
 739                        insertAtColumnID);
 740            }
 741
 0742            return -1;
 0743        }
 744
 745        public override void RemoveColumn(Serializable.SerializableTypes columnType, int columnID)
 0746        {
 0747            switch (columnType)
 748            {
 749                case Serializable.SerializableTypes.String:
 0750                    RemoveColumnInternal(ref AllStringColumns, Serializable.SerializableTypes.String, columnID);
 0751                    break;
 752                case Serializable.SerializableTypes.Char:
 0753                    RemoveColumnInternal(ref AllCharColumns, Serializable.SerializableTypes.Char, columnID);
 0754                    break;
 755                case Serializable.SerializableTypes.Bool:
 0756                    RemoveColumnInternal(ref AllBoolColumns, Serializable.SerializableTypes.Bool, columnID);
 0757                    break;
 758                case Serializable.SerializableTypes.SByte:
 0759                    RemoveColumnInternal(ref AllSbyteColumns, Serializable.SerializableTypes.SByte, columnID);
 0760                    break;
 761                case Serializable.SerializableTypes.Byte:
 0762                    RemoveColumnInternal(ref AllByteColumns, Serializable.SerializableTypes.Byte, columnID);
 0763                    break;
 764                case Serializable.SerializableTypes.Short:
 0765                    RemoveColumnInternal(ref AllShortColumns, Serializable.SerializableTypes.Short, columnID);
 0766                    break;
 767                case Serializable.SerializableTypes.UShort:
 0768                    RemoveColumnInternal(ref AllUshortColumns, Serializable.SerializableTypes.UShort, columnID);
 0769                    break;
 770                case Serializable.SerializableTypes.Int:
 0771                    RemoveColumnInternal(ref AllIntColumns, Serializable.SerializableTypes.Int, columnID);
 0772                    break;
 773                case Serializable.SerializableTypes.UInt:
 0774                    RemoveColumnInternal(ref AllUintColumns, Serializable.SerializableTypes.UInt, columnID);
 0775                    break;
 776                case Serializable.SerializableTypes.Long:
 0777                    RemoveColumnInternal(ref AllLongColumns, Serializable.SerializableTypes.Long, columnID);
 0778                    break;
 779                case Serializable.SerializableTypes.ULong:
 0780                    RemoveColumnInternal(ref AllUlongColumns, Serializable.SerializableTypes.ULong, columnID);
 0781                    break;
 782                case Serializable.SerializableTypes.Float:
 0783                    RemoveColumnInternal(ref AllFloatColumns, Serializable.SerializableTypes.Float, columnID);
 0784                    break;
 785                case Serializable.SerializableTypes.Double:
 0786                    RemoveColumnInternal(ref AllDoubleColumns, Serializable.SerializableTypes.Double, columnID);
 0787                    break;
 788                case Serializable.SerializableTypes.Vector2:
 0789                    RemoveColumnInternal(ref AllVector2Columns, Serializable.SerializableTypes.Vector2, columnID);
 0790                    break;
 791                case Serializable.SerializableTypes.Vector3:
 0792                    RemoveColumnInternal(ref AllVector3Columns, Serializable.SerializableTypes.Vector3, columnID);
 0793                    break;
 794                case Serializable.SerializableTypes.Vector4:
 0795                    RemoveColumnInternal(ref AllVector4Columns, Serializable.SerializableTypes.Vector4, columnID);
 0796                    break;
 797                case Serializable.SerializableTypes.Vector2Int:
 0798                    RemoveColumnInternal(ref AllVector2IntColumns, Serializable.SerializableTypes.Vector2Int, columnID);
 0799                    break;
 800                case Serializable.SerializableTypes.Vector3Int:
 0801                    RemoveColumnInternal(ref AllVector3IntColumns, Serializable.SerializableTypes.Vector3Int, columnID);
 0802                    break;
 803                case Serializable.SerializableTypes.Quaternion:
 0804                    RemoveColumnInternal(ref AllQuaternionColumns, Serializable.SerializableTypes.Quaternion, columnID);
 0805                    break;
 806                case Serializable.SerializableTypes.Rect:
 0807                    RemoveColumnInternal(ref AllRectColumns, Serializable.SerializableTypes.Rect, columnID);
 0808                    break;
 809                case Serializable.SerializableTypes.RectInt:
 0810                    RemoveColumnInternal(ref AllRectIntColumns, Serializable.SerializableTypes.RectInt, columnID);
 0811                    break;
 812                case Serializable.SerializableTypes.Color:
 0813                    RemoveColumnInternal(ref AllColorColumns, Serializable.SerializableTypes.Color, columnID);
 0814                    break;
 815                case Serializable.SerializableTypes.LayerMask:
 0816                    RemoveColumnInternal(ref AllLayerMaskColumns, Serializable.SerializableTypes.LayerMask, columnID);
 0817                    break;
 818                case Serializable.SerializableTypes.Bounds:
 0819                    RemoveColumnInternal(ref AllBoundsColumns, Serializable.SerializableTypes.Bounds, columnID);
 0820                    break;
 821                case Serializable.SerializableTypes.BoundsInt:
 0822                    RemoveColumnInternal(ref AllBoundsIntColumns, Serializable.SerializableTypes.BoundsInt, columnID);
 0823                    break;
 824                case Serializable.SerializableTypes.Hash128:
 0825                    RemoveColumnInternal(ref AllHash128Columns, Serializable.SerializableTypes.Hash128, columnID);
 0826                    break;
 827                case Serializable.SerializableTypes.Gradient:
 0828                    RemoveColumnInternal(ref AllGradientColumns, Serializable.SerializableTypes.Gradient, columnID);
 0829                    break;
 830                case Serializable.SerializableTypes.AnimationCurve:
 0831                    RemoveColumnInternal(ref AllAnimationCurveColumns, Serializable.SerializableTypes.AnimationCurve,
 832                        columnID);
 0833                    break;
 834                case Serializable.SerializableTypes.Object:
 0835                    RemoveColumnInternal(ref AllObjectRefColumns, Serializable.SerializableTypes.Object, columnID);
 0836                    break;
 837            }
 0838        }
 839
 840        // Set
 841
 842        public override ulong SetString(int row, int column, string value)
 0843        {
 0844            return SetCell(row, column, ref AllStringColumns, value);
 0845        }
 846
 847        public override ulong SetBool(int row, int column, bool value)
 0848        {
 0849            return SetCell(row, column, ref AllBoolColumns, value);
 0850        }
 851
 852        public override ulong SetChar(int row, int column, char value)
 0853        {
 0854            return SetCell(row, column, ref AllCharColumns, value);
 0855        }
 856
 857        public override ulong SetSByte(int row, int column, sbyte value)
 0858        {
 0859            return SetCell(row, column, ref AllSbyteColumns, value);
 0860        }
 861
 862        public override ulong SetByte(int row, int column, byte value)
 0863        {
 0864            return SetCell(row, column, ref AllByteColumns, value);
 0865        }
 866
 867        public override ulong SetShort(int row, int column, short value)
 0868        {
 0869            return SetCell(row, column, ref AllShortColumns, value);
 0870        }
 871
 872        public override ulong SetUShort(int row, int column, ushort value)
 0873        {
 0874            return SetCell(row, column, ref AllUshortColumns, value);
 0875        }
 876
 877        public override ulong SetInt(int row, int column, int value)
 0878        {
 0879            return SetCell(row, column, ref AllIntColumns, value);
 0880        }
 881
 882        public override ulong SetUInt(int row, int column, uint value)
 0883        {
 0884            return SetCell(row, column, ref AllUintColumns, value);
 0885        }
 886
 887        public override ulong SetLong(int row, int column, long value)
 0888        {
 0889            return SetCell(row, column, ref AllLongColumns, value);
 0890        }
 891
 892        public override ulong SetULong(int row, int column, ulong value)
 0893        {
 0894            return SetCell(row, column, ref AllUlongColumns, value);
 0895        }
 896
 897        public override ulong SetFloat(int row, int column, float value)
 0898        {
 0899            return SetCell(row, column, ref AllFloatColumns, value);
 0900        }
 901
 902        public override ulong SetDouble(int row, int column, double value)
 0903        {
 0904            return SetCell(row, column, ref AllDoubleColumns, value);
 0905        }
 906
 907        public override ulong SetVector2(int row, int column, Vector2 value)
 0908        {
 0909            return SetCell(row, column, ref AllVector2Columns, value);
 0910        }
 911
 912        public override ulong SetVector3(int row, int column, Vector3 value)
 0913        {
 0914            return SetCell(row, column, ref AllVector3Columns, value);
 0915        }
 916
 917        public override ulong SetVector4(int row, int column, Vector4 value)
 0918        {
 0919            return SetCell(row, column, ref AllVector4Columns, value);
 0920        }
 921
 922        public override ulong SetVector2Int(int row, int column, Vector2Int value)
 0923        {
 0924            return SetCell(row, column, ref AllVector2IntColumns, value);
 0925        }
 926
 927        public override ulong SetVector3Int(int row, int column, Vector3Int value)
 0928        {
 0929            return SetCell(row, column, ref AllVector3IntColumns, value);
 0930        }
 931
 932        public override ulong SetQuaternion(int row, int column, Quaternion value)
 0933        {
 0934            return SetCell(row, column, ref AllQuaternionColumns, value);
 0935        }
 936
 937        public override ulong SetRect(int row, int column, Rect value)
 0938        {
 0939            return SetCell(row, column, ref AllRectColumns, value);
 0940        }
 941
 942        public override ulong SetRectInt(int row, int column, RectInt value)
 0943        {
 0944            return SetCell(row, column, ref AllRectIntColumns, value);
 0945        }
 946
 947        public override ulong SetColor(int row, int column, Color value)
 0948        {
 0949            return SetCell(row, column, ref AllColorColumns, value);
 0950        }
 951
 952        public override ulong SetLayerMask(int row, int column, LayerMask value)
 0953        {
 0954            return SetCell(row, column, ref AllLayerMaskColumns, value);
 0955        }
 956
 957        public override ulong SetBounds(int row, int column, Bounds value)
 0958        {
 0959            return SetCell(row, column, ref AllBoundsColumns, value);
 0960        }
 961
 962        public override ulong SetBoundsInt(int row, int column, BoundsInt value)
 0963        {
 0964            return SetCell(row, column, ref AllBoundsIntColumns, value);
 0965        }
 966
 967        public override ulong SetHash128(int row, int column, Hash128 value)
 0968        {
 0969            return SetCell(row, column, ref AllHash128Columns, value);
 0970        }
 971
 972        public override ulong SetGradient(int row, int column, Gradient value)
 0973        {
 0974            return SetCell(row, column, ref AllGradientColumns, value);
 0975        }
 976
 977        public override ulong SetAnimationCurve(int row, int column, AnimationCurve value)
 0978        {
 0979            return SetCell(row, column, ref AllAnimationCurveColumns, value);
 0980        }
 981
 982        public override ulong SetObject(int row, int column, Object value)
 0983        {
 0984            return SetCell(row, column, ref AllObjectRefColumns, value);
 0985        }
 986
 987        public override void SetTypeNameForObjectColumn(int columnID, string assemblyQualifiedName)
 0988        {
 0989            AssertObjectColumnIDValid(columnID);
 0990            int denseIndex = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 0991            AllObjectRefTypeNames[denseIndex] = assemblyQualifiedName;
 0992        }
 993        public override string GetTypeNameForObjectColumn(int columnID)
 0994        {
 0995            AssertObjectColumnIDValid(columnID);
 0996            int denseIndex = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 0997            return AllObjectRefTypeNames[denseIndex];
 0998        }
 999
 1000        // Get
 1001        public override string GetString(int row, int column)
 01002        {
 01003            return GetCell(row, column, ref AllStringColumns);
 01004        }
 1005
 1006        public override bool GetBool(int row, int column)
 01007        {
 01008            return GetCell(row, column, ref AllBoolColumns);
 01009        }
 1010
 1011        public override char GetChar(int row, int column)
 01012        {
 01013            return GetCell(row, column, ref AllCharColumns);
 01014        }
 1015
 1016        public override sbyte GetSByte(int row, int column)
 01017        {
 01018            return GetCell(row, column, ref AllSbyteColumns);
 01019        }
 1020
 1021        public override byte GetByte(int row, int column)
 01022        {
 01023            return GetCell(row, column, ref AllByteColumns);
 01024        }
 1025
 1026        public override short GetShort(int row, int column)
 01027        {
 01028            return GetCell(row, column, ref AllShortColumns);
 01029        }
 1030
 1031        public override ushort GetUShort(int row, int column)
 01032        {
 01033            return GetCell(row, column, ref AllUshortColumns);
 01034        }
 1035
 1036        public override int GetInt(int row, int column)
 01037        {
 01038            return GetCell(row, column, ref AllIntColumns);
 01039        }
 1040
 1041        public override uint GetUInt(int row, int column)
 01042        {
 01043            return GetCell(row, column, ref AllUintColumns);
 01044        }
 1045
 1046        public override long GetLong(int row, int column)
 01047        {
 01048            return GetCell(row, column, ref AllLongColumns);
 01049        }
 1050
 1051        public override ulong GetULong(int row, int column)
 01052        {
 01053            return GetCell(row, column, ref AllUlongColumns);
 01054        }
 1055
 1056        public override float GetFloat(int row, int column)
 01057        {
 01058            return GetCell(row, column, ref AllFloatColumns);
 01059        }
 1060
 1061        public override double GetDouble(int row, int column)
 01062        {
 01063            return GetCell(row, column, ref AllDoubleColumns);
 01064        }
 1065
 1066        public override Vector2 GetVector2(int row, int column)
 01067        {
 01068            return GetCell(row, column, ref AllVector2Columns);
 01069        }
 1070
 1071        public override Vector3 GetVector3(int row, int column)
 01072        {
 01073            return GetCell(row, column, ref AllVector3Columns);
 01074        }
 1075
 1076        public override Vector4 GetVector4(int row, int column)
 01077        {
 01078            return GetCell(row, column, ref AllVector4Columns);
 01079        }
 1080
 1081        public override Vector2Int GetVector2Int(int row, int column)
 01082        {
 01083            return GetCell(row, column, ref AllVector2IntColumns);
 01084        }
 1085
 1086        public override Vector3Int GetVector3Int(int row, int column)
 01087        {
 01088            return GetCell(row, column, ref AllVector3IntColumns);
 01089        }
 1090
 1091        public override Quaternion GetQuaternion(int row, int column)
 01092        {
 01093            return GetCell(row, column, ref AllQuaternionColumns);
 01094        }
 1095
 1096        public override Rect GetRect(int row, int column)
 01097        {
 01098            return GetCell(row, column, ref AllRectColumns);
 01099        }
 1100
 1101        public override RectInt GetRectInt(int row, int column)
 01102        {
 01103            return GetCell(row, column, ref AllRectIntColumns);
 01104        }
 1105
 1106        public override Color GetColor(int row, int column)
 01107        {
 01108            return GetCell(row, column, ref AllColorColumns);
 01109        }
 1110
 1111        public override LayerMask GetLayerMask(int row, int column)
 01112        {
 01113            return GetCell(row, column, ref AllLayerMaskColumns);
 01114        }
 1115
 1116        public override Bounds GetBounds(int row, int column)
 01117        {
 01118            return GetCell(row, column, ref AllBoundsColumns);
 01119        }
 1120
 1121        public override BoundsInt GetBoundsInt(int row, int column)
 01122        {
 01123            return GetCell(row, column, ref AllBoundsIntColumns);
 01124        }
 1125
 1126        public override Hash128 GetHash128(int row, int column)
 01127        {
 01128            return GetCell(row, column, ref AllHash128Columns);
 01129        }
 1130
 1131        public override Gradient GetGradient(int row, int column)
 01132        {
 01133            return GetCell(row, column, ref AllGradientColumns);
 01134        }
 1135
 1136        public override AnimationCurve GetAnimationCurve(int row, int column)
 01137        {
 01138            return GetCell(row, column, ref AllAnimationCurveColumns);
 01139        }
 1140
 1141        public override Object GetObject(int row, int column)
 01142        {
 01143            return GetCell(row, column, ref AllObjectRefColumns);
 01144        }
 1145
 1146        // Get ref
 1147
 1148        public ref string GetStringRef(int row, int column)
 01149        {
 01150            return ref GetCellRef(row, column, ref AllStringColumns);
 01151        }
 1152
 1153        public ref bool GetBoolRef(int row, int column)
 01154        {
 01155            return ref GetCellRef(row, column, ref AllBoolColumns);
 01156        }
 1157
 1158        public ref char GetCharRef(int row, int column)
 01159        {
 01160            return ref GetCellRef(row, column, ref AllCharColumns);
 01161        }
 1162
 1163        public ref sbyte GetSbyteRef(int row, int column)
 01164        {
 01165            return ref GetCellRef(row, column, ref AllSbyteColumns);
 01166        }
 1167
 1168        public ref byte GetByteRef(int row, int columnID)
 01169        {
 01170            return ref GetCellRef(row, columnID, ref AllByteColumns);
 01171        }
 1172
 1173        public ref short GetShortRef(int row, int column)
 01174        {
 01175            return ref GetCellRef(row, column, ref AllShortColumns);
 01176        }
 1177
 1178        public ref ushort GetUshortRef(int row, int column)
 01179        {
 01180            return ref GetCellRef(row, column, ref AllUshortColumns);
 01181        }
 1182
 1183        public ref int GetIntRef(int row, int column)
 01184        {
 01185            return ref GetCellRef(row, column, ref AllIntColumns);
 01186        }
 1187
 1188        public ref uint GetUintRef(int row, int column)
 01189        {
 01190            return ref GetCellRef(row, column, ref AllUintColumns);
 01191        }
 1192
 1193        public ref long GetLongRef(int row, int column)
 01194        {
 01195            return ref GetCellRef(row, column, ref AllLongColumns);
 01196        }
 1197
 1198        public ref ulong GetUlongRef(int row, int column)
 01199        {
 01200            return ref GetCellRef(row, column, ref AllUlongColumns);
 01201        }
 1202
 1203        public ref float GetFloatRef(int row, int column)
 01204        {
 01205            return ref GetCellRef(row, column, ref AllFloatColumns);
 01206        }
 1207
 1208        public ref double GetDoubleRef(int row, int column)
 01209        {
 01210            return ref GetCellRef(row, column, ref AllDoubleColumns);
 01211        }
 1212
 1213        public ref Vector2 GetVector2Ref(int row, int column)
 01214        {
 01215            return ref GetCellRef(row, column, ref AllVector2Columns);
 01216        }
 1217
 1218        public ref Vector3 GetVector3Ref(int row, int column)
 01219        {
 01220            return ref GetCellRef(row, column, ref AllVector3Columns);
 01221        }
 1222
 1223        public ref Vector4 GetVector4Ref(int row, int column)
 01224        {
 01225            return ref GetCellRef(row, column, ref AllVector4Columns);
 01226        }
 1227
 1228        public ref Vector2Int GetVector2IntRef(int row, int column)
 01229        {
 01230            return ref GetCellRef(row, column, ref AllVector2IntColumns);
 01231        }
 1232
 1233        public ref Vector3Int GetVector3IntRef(int row, int column)
 01234        {
 01235            return ref GetCellRef(row, column, ref AllVector3IntColumns);
 01236        }
 1237
 1238        public ref Quaternion GetQuaternionRef(int row, int column)
 01239        {
 01240            return ref GetCellRef(row, column, ref AllQuaternionColumns);
 01241        }
 1242
 1243        public ref Rect GetRectRef(int row, int column)
 01244        {
 01245            return ref GetCellRef(row, column, ref AllRectColumns);
 01246        }
 1247
 1248        public ref RectInt GetRectIntRef(int row, int column)
 01249        {
 01250            return ref GetCellRef(row, column, ref AllRectIntColumns);
 01251        }
 1252
 1253        public ref Color GetColorRef(int row, int column)
 01254        {
 01255            return ref GetCellRef(row, column, ref AllColorColumns);
 01256        }
 1257
 1258        public ref LayerMask GetLayerMaskRef(int row, int column)
 01259        {
 01260            return ref GetCellRef(row, column, ref AllLayerMaskColumns);
 01261        }
 1262
 1263        public ref Bounds GetBoundsRef(int row, int column)
 01264        {
 01265            return ref GetCellRef(row, column, ref AllBoundsColumns);
 01266        }
 1267
 1268        public ref BoundsInt GetBoundsIntRef(int row, int column)
 01269        {
 01270            return ref GetCellRef(row, column, ref AllBoundsIntColumns);
 01271        }
 1272
 1273        public ref Hash128 GetHash128Ref(int row, int column)
 01274        {
 01275            return ref GetCellRef(row, column, ref AllHash128Columns);
 01276        }
 1277
 1278        public ref Gradient GetGradientRef(int row, int column)
 01279        {
 01280            return ref GetCellRef(row, column, ref AllGradientColumns);
 01281        }
 1282
 1283        public ref AnimationCurve GetAnimationCurveRef(int row, int column)
 01284        {
 01285            return ref GetCellRef(row, column, ref AllAnimationCurveColumns);
 01286        }
 1287
 1288        public ref Object GetObjectRef(int row, int column)
 01289        {
 01290            return ref GetCellRef(row, column, ref AllObjectRefColumns);
 01291        }
 1292
 1293        // Get Column
 1294
 1295        public string[] GetStringColumn(int column)
 01296        {
 01297            return GetColumn(column, ref AllStringColumns);
 01298        }
 1299
 1300        public bool[] GetBoolColumn(int column)
 01301        {
 01302            return GetColumn(column, ref AllBoolColumns);
 01303        }
 1304
 1305        public char[] GetCharColumn(int column)
 01306        {
 01307            return GetColumn(column, ref AllCharColumns);
 01308        }
 1309
 1310        public sbyte[] GetSbyteColumn(int column)
 01311        {
 01312            return GetColumn(column, ref AllSbyteColumns);
 01313        }
 1314
 1315        public byte[] GetByteColumn(int column)
 01316        {
 01317            return GetColumn(column, ref AllByteColumns);
 01318        }
 1319
 1320        public short[] GetShortColumn(int column)
 01321        {
 01322            return GetColumn(column, ref AllShortColumns);
 01323        }
 1324
 1325        public ushort[] GetUshortColumn(int column)
 01326        {
 01327            return GetColumn(column, ref AllUshortColumns);
 01328        }
 1329
 1330        public int[] GetIntColumn(int column)
 01331        {
 01332            return GetColumn(column, ref AllIntColumns);
 01333        }
 1334
 1335        public uint[] GetUintColumn(int column)
 01336        {
 01337            return GetColumn(column, ref AllUintColumns);
 01338        }
 1339
 1340        public long[] GetLongColumn(int column)
 01341        {
 01342            return GetColumn(column, ref AllLongColumns);
 01343        }
 1344
 1345        public ulong[] GetUlongColumn(int column)
 01346        {
 01347            return GetColumn(column, ref AllUlongColumns);
 01348        }
 1349
 1350        public float[] GetFloatColumn(int column)
 01351        {
 01352            return GetColumn(column, ref AllFloatColumns);
 01353        }
 1354
 1355        public double[] GetDoubleColumn(int column)
 01356        {
 01357            return GetColumn(column, ref AllDoubleColumns);
 01358        }
 1359
 1360        public Vector2[] GetVector2Column(int column)
 01361        {
 01362            return GetColumn(column, ref AllVector2Columns);
 01363        }
 1364
 1365        public Vector3[] GetVector3Column(int column)
 01366        {
 01367            return GetColumn(column, ref AllVector3Columns);
 01368        }
 1369
 1370        public Vector4[] GetVector4Column(int column)
 01371        {
 01372            return GetColumn(column, ref AllVector4Columns);
 01373        }
 1374
 1375        public Vector2Int[] GetVector2IntColumn(int column)
 01376        {
 01377            return GetColumn(column, ref AllVector2IntColumns);
 01378        }
 1379
 1380        public Vector3Int[] GetVector3IntColumn(int column)
 01381        {
 01382            return GetColumn(column, ref AllVector3IntColumns);
 01383        }
 1384
 1385        public Quaternion[] GetQuaternionColumn(int column)
 01386        {
 01387            return GetColumn(column, ref AllQuaternionColumns);
 01388        }
 1389
 1390        public Rect[] GetRectColumn(int column)
 01391        {
 01392            return GetColumn(column, ref AllRectColumns);
 01393        }
 1394
 1395        public RectInt[] GetRectIntColumn(int column)
 01396        {
 01397            return GetColumn(column, ref AllRectIntColumns);
 01398        }
 1399
 1400        public Color[] GetColorColumn(int column)
 01401        {
 01402            return GetColumn(column, ref AllColorColumns);
 01403        }
 1404
 1405        public LayerMask[] GetLayerMaskColumn(int column)
 01406        {
 01407            return GetColumn(column, ref AllLayerMaskColumns);
 01408        }
 1409
 1410        public Bounds[] GetBoundsColumn(int column)
 01411        {
 01412            return GetColumn(column, ref AllBoundsColumns);
 01413        }
 1414
 1415        public BoundsInt[] GetBoundsIntColumn(int column)
 01416        {
 01417            return GetColumn(column, ref AllBoundsIntColumns);
 01418        }
 1419
 1420        public Hash128[] GetHash128Column(int column)
 01421        {
 01422            return GetColumn(column, ref AllHash128Columns);
 01423        }
 1424
 1425        public Gradient[] GetGradientColumn(int column)
 01426        {
 01427            return GetColumn(column, ref AllGradientColumns);
 01428        }
 1429
 1430        public AnimationCurve[] GetAnimationCurveColumn(int column)
 01431        {
 01432            return GetColumn(column, ref AllAnimationCurveColumns);
 01433        }
 1434
 1435        public Object[] GetObjectColumn(int column)
 01436        {
 01437            return GetColumn(column, ref AllObjectRefColumns);
 01438        }
 1439
 1440        // SetOrder
 1441
 1442        public void SetColumnOrder(int columnID, int newSortOrder)
 01443        {
 01444            AssertColumnIDValid(columnID);
 01445            AssertColumnSortOrderValid(newSortOrder);
 01446            int oldSortOrder = ColumnIDToSortOrderMap[columnID];
 01447            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01448            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01449            {
 01450                int columnIDAt = SortedOrderToColumnIDMap[i + iterDirection];
 01451                ColumnIDToSortOrderMap[columnIDAt] = i;
 01452                SortedOrderToColumnIDMap[i] = SortedOrderToColumnIDMap[i + iterDirection];
 01453            }
 1454
 01455            SortedOrderToColumnIDMap[newSortOrder] = columnID;
 01456            ColumnIDToSortOrderMap[columnID] = newSortOrder;
 01457        }
 1458
 1459        public void SetAllColumnOrders(int[] sortedColumnIDs)
 01460        {
 01461            AssertSortedColumnsArgValid(sortedColumnIDs);
 01462            for (int i = 0; i < SortedOrderToColumnIDMap.Length; i++)
 01463            {
 01464                int columnID = sortedColumnIDs[i];
 01465                SortedOrderToColumnIDMap[i] = columnID;
 01466                ColumnIDToSortOrderMap[columnID] = i;
 01467            }
 01468        }
 1469
 1470        public void SetRowOrder(int rowID, int newSortOrder)
 01471        {
 01472            AssertRowIDValid(rowID);
 01473            AssertRowSortOrderValid(newSortOrder);
 1474
 01475            int oldSortOrder = RowIDToDenseIndexMap[rowID];
 01476            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 1477
 01478            for (int i = oldSortOrder; i != newSortOrder; i += iterDirection)
 01479            {
 01480                int rowIDAt = RowDenseIndexToIDMap[i + iterDirection];
 01481                RowIDToDenseIndexMap[rowIDAt] = i;
 01482                RowDenseIndexToIDMap[i] = RowDenseIndexToIDMap[i + iterDirection];
 01483            }
 1484
 01485            SetRowOrderForColumns(AllStringColumns, oldSortOrder, newSortOrder);
 01486            SetRowOrderForColumns(AllBoolColumns, oldSortOrder, newSortOrder);
 01487            SetRowOrderForColumns(AllCharColumns, oldSortOrder, newSortOrder);
 01488            SetRowOrderForColumns(AllSbyteColumns, oldSortOrder, newSortOrder);
 01489            SetRowOrderForColumns(AllByteColumns, oldSortOrder, newSortOrder);
 01490            SetRowOrderForColumns(AllShortColumns, oldSortOrder, newSortOrder);
 01491            SetRowOrderForColumns(AllUshortColumns, oldSortOrder, newSortOrder);
 01492            SetRowOrderForColumns(AllIntColumns, oldSortOrder, newSortOrder);
 01493            SetRowOrderForColumns(AllUintColumns, oldSortOrder, newSortOrder);
 01494            SetRowOrderForColumns(AllLongColumns, oldSortOrder, newSortOrder);
 01495            SetRowOrderForColumns(AllUlongColumns, oldSortOrder, newSortOrder);
 01496            SetRowOrderForColumns(AllFloatColumns, oldSortOrder, newSortOrder);
 01497            SetRowOrderForColumns(AllDoubleColumns, oldSortOrder, newSortOrder);
 01498            SetRowOrderForColumns(AllVector2Columns, oldSortOrder, newSortOrder);
 01499            SetRowOrderForColumns(AllVector3Columns, oldSortOrder, newSortOrder);
 01500            SetRowOrderForColumns(AllVector4Columns, oldSortOrder, newSortOrder);
 01501            SetRowOrderForColumns(AllVector2IntColumns, oldSortOrder, newSortOrder);
 01502            SetRowOrderForColumns(AllVector3IntColumns, oldSortOrder, newSortOrder);
 01503            SetRowOrderForColumns(AllQuaternionColumns, oldSortOrder, newSortOrder);
 01504            SetRowOrderForColumns(AllRectColumns, oldSortOrder, newSortOrder);
 01505            SetRowOrderForColumns(AllRectIntColumns, oldSortOrder, newSortOrder);
 01506            SetRowOrderForColumns(AllColorColumns, oldSortOrder, newSortOrder);
 01507            SetRowOrderForColumns(AllLayerMaskColumns, oldSortOrder, newSortOrder);
 01508            SetRowOrderForColumns(AllBoundsColumns, oldSortOrder, newSortOrder);
 01509            SetRowOrderForColumns(AllBoundsIntColumns, oldSortOrder, newSortOrder);
 01510            SetRowOrderForColumns(AllHash128Columns, oldSortOrder, newSortOrder);
 01511            SetRowOrderForColumns(AllGradientColumns, oldSortOrder, newSortOrder);
 01512            SetRowOrderForColumns(AllAnimationCurveColumns, oldSortOrder, newSortOrder);
 01513            SetRowOrderForColumns(AllObjectRefColumns, oldSortOrder, newSortOrder);
 01514        }
 1515
 1516        public void SetAllRowOrders(int[] sortedRowIDs)
 01517        {
 01518            AssertSortRowsArgValid(sortedRowIDs);
 1519
 01520            ReSortRows(AllStringColumns, sortedRowIDs);
 01521            ReSortRows(AllBoolColumns, sortedRowIDs);
 01522            ReSortRows(AllCharColumns, sortedRowIDs);
 01523            ReSortRows(AllSbyteColumns, sortedRowIDs);
 01524            ReSortRows(AllByteColumns, sortedRowIDs);
 01525            ReSortRows(AllShortColumns, sortedRowIDs);
 01526            ReSortRows(AllUshortColumns, sortedRowIDs);
 01527            ReSortRows(AllIntColumns, sortedRowIDs);
 01528            ReSortRows(AllUintColumns, sortedRowIDs);
 01529            ReSortRows(AllLongColumns, sortedRowIDs);
 01530            ReSortRows(AllUlongColumns, sortedRowIDs);
 01531            ReSortRows(AllFloatColumns, sortedRowIDs);
 01532            ReSortRows(AllDoubleColumns, sortedRowIDs);
 01533            ReSortRows(AllVector2Columns, sortedRowIDs);
 01534            ReSortRows(AllVector3Columns, sortedRowIDs);
 01535            ReSortRows(AllVector4Columns, sortedRowIDs);
 01536            ReSortRows(AllVector2IntColumns, sortedRowIDs);
 01537            ReSortRows(AllVector3IntColumns, sortedRowIDs);
 01538            ReSortRows(AllQuaternionColumns, sortedRowIDs);
 01539            ReSortRows(AllRectColumns, sortedRowIDs);
 01540            ReSortRows(AllRectIntColumns, sortedRowIDs);
 01541            ReSortRows(AllColorColumns, sortedRowIDs);
 01542            ReSortRows(AllLayerMaskColumns, sortedRowIDs);
 01543            ReSortRows(AllBoundsColumns, sortedRowIDs);
 01544            ReSortRows(AllBoundsIntColumns, sortedRowIDs);
 01545            ReSortRows(AllHash128Columns, sortedRowIDs);
 01546            ReSortRows(AllGradientColumns, sortedRowIDs);
 01547            ReSortRows(AllAnimationCurveColumns, sortedRowIDs);
 01548            ReSortRows(AllObjectRefColumns, sortedRowIDs);
 1549
 01550            for (int i = 0; i < sortedRowIDs.Length; i++)
 01551            {
 01552                int rowID = sortedRowIDs[i];
 01553                RowDenseIndexToIDMap[i] = rowID;
 01554                RowIDToDenseIndexMap[rowID] = i;
 01555            }
 01556        }
 1557
 1558        internal void ReSortRows<T>(ArrayHolder<T>[] columns, int[] sortedRowIDs)
 01559        {
 01560            int columnCount = columns?.Length ?? 0;
 01561            for (int i = 0; i < columnCount; i++)
 01562            {
 01563                T[] column = columns[i].TArray;
 01564                T[] newColumn = new T[column.Length];
 01565                for (int j = 0; j < sortedRowIDs.Length; j++)
 01566                {
 01567                    int rowID = sortedRowIDs[j];
 01568                    int oldRowIndex = RowIDToDenseIndexMap[rowID];
 1569
 01570                    newColumn[j] = column[oldRowIndex];
 01571                }
 1572
 01573                columns[i].TArray = newColumn;
 01574            }
 01575        }
 1576
 1577        // Internal
 1578
 1579        internal void AddTypeNameEntryForUnityObjectColumn()
 01580        {
 01581            int nameArrayLength = AllObjectRefTypeNames?.Length ?? 0;
 01582            Array.Resize(ref AllObjectRefTypeNames, nameArrayLength + 1);
 01583            AllObjectRefTypeNames[nameArrayLength] = UnityObjectString;
 01584        }
 1585
 1586        internal void RemoveTypeNameEntryForUnityObjectColumn(int columnDenseIndex)
 01587        {
 01588            int nameArrayLength = AllObjectRefTypeNames?.Length ?? 0;
 01589            AllObjectRefTypeNames[columnDenseIndex] = AllObjectRefTypeNames[nameArrayLength];
 01590            Array.Resize(ref AllObjectRefTypeNames, nameArrayLength - 1);
 01591        }
 1592
 1593        internal void AssertObjectColumnIDValid(int columnID)
 01594        {
 01595            AssertColumnIDValid(columnID);
 01596            if (ColumnIDToDenseIndexMap[columnID].ColumnType != Serializable.SerializableTypes.Object)
 01597            {
 01598                throw new ArgumentException("Column ID must correspond to a UnityEngine.Object column.");
 1599            }
 01600        }
 1601
 1602        internal int AddColumnInternal<T>(string columnName, ref ArrayHolder<T>[] allColumnsOfType,
 1603            Serializable.SerializableTypes typeIndex, int insertAtColumnID)
 01604        {
 01605            if (insertAtColumnID >= 0)
 01606            {
 01607                AssertColumnIDValid(insertAtColumnID);
 01608            }
 1609
 01610            int columnCount = allColumnsOfType?.Length ?? 0;
 01611            Array.Resize(ref allColumnsOfType, columnCount + 1);
 01612            allColumnsOfType[columnCount].TArray = new T[RowCount];
 1613
 01614            int columnID = ColumnEntriesFreeListHead;
 01615            string[] columnNamesForType = AllColumnNames[(int)typeIndex].TArray;
 01616            int columnNamesCount = columnNamesForType?.Length ?? 0;
 01617            Array.Resize(ref columnNamesForType, columnNamesCount + 1);
 01618            columnNamesForType[columnNamesCount] = columnName == null ? columnID.ToString() : columnName;
 01619            AllColumnNames[(int)typeIndex].TArray = columnNamesForType;
 1620
 1621
 01622            int columnIDToDenseIndexMapLength = ColumnIDToDenseIndexMap?.Length ?? 0;
 01623            if (columnID >= columnIDToDenseIndexMapLength)
 01624            {
 01625                int newSize = columnIDToDenseIndexMapLength * 2;
 01626                newSize = newSize == 0 ? 1 : newSize;
 01627                Array.Resize(ref ColumnIDToDenseIndexMap, newSize);
 01628                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01629                {
 01630                    ref ColumnEntry entry = ref ColumnIDToDenseIndexMap[i];
 01631                    entry.ColumnDenseIndex = i + 1;
 01632                    entry.ColumnType = Serializable.SerializableTypes.Invalid;
 01633                }
 1634
 01635                Array.Resize(ref ColumnIDToSortOrderMap, newSize);
 01636                for (int i = columnIDToDenseIndexMapLength; i < newSize; i++)
 01637                {
 01638                    ColumnIDToSortOrderMap[i] = -1;
 01639                }
 01640            }
 1641
 01642            ColumnEntriesFreeListHead = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 1643
 01644            ref int[] denseIndexToIDMap = ref ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 01645            int denseIndexToIDMapLength = denseIndexToIDMap?.Length ?? 0;
 01646            Array.Resize(ref denseIndexToIDMap, denseIndexToIDMapLength + 1);
 01647            denseIndexToIDMap[denseIndexToIDMapLength] = columnID;
 1648
 01649            ref ColumnEntry newEntry = ref ColumnIDToDenseIndexMap[columnID];
 01650            newEntry.ColumnDenseIndex = denseIndexToIDMapLength;
 01651            newEntry.ColumnType = typeIndex;
 1652
 01653            int insertAtSortedIndex =
 1654                insertAtColumnID < 0 ? CombinedColumnCount : ColumnIDToSortOrderMap[insertAtColumnID];
 01655            Array.Resize(ref SortedOrderToColumnIDMap, CombinedColumnCount + 1);
 01656            for (int i = CombinedColumnCount; i > insertAtSortedIndex; i--)
 01657            {
 01658                int currentColumnID = SortedOrderToColumnIDMap[i - 1];
 01659                SortedOrderToColumnIDMap[i] = currentColumnID;
 01660                ColumnIDToSortOrderMap[currentColumnID] = i;
 01661            }
 1662
 01663            if (typeIndex == Serializable.SerializableTypes.Object)
 01664            {
 01665                AddTypeNameEntryForUnityObjectColumn();
 01666            }
 1667
 01668            ColumnIDToSortOrderMap[columnID] = insertAtSortedIndex;
 01669            SortedOrderToColumnIDMap[insertAtSortedIndex] = columnID;
 1670
 01671            ++CombinedColumnCount;
 01672            DataVersion++;
 1673
 01674            return columnID;
 01675        }
 1676
 1677        internal void RemoveColumnInternal<T>(ref ArrayHolder<T>[] allColumnsOfType,
 1678            Serializable.SerializableTypes typeIndex, int columnID)
 01679        {
 01680            AssertColumnIDValid(columnID);
 01681            int columnLocation = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 1682
 01683            int lastIndex = allColumnsOfType.Length - 1;
 01684            allColumnsOfType[columnLocation] = allColumnsOfType[lastIndex];
 01685            Array.Resize(ref allColumnsOfType, lastIndex);
 1686
 01687            ref string[] columnNamesOfType = ref AllColumnNames[(int)typeIndex].TArray;
 01688            columnNamesOfType[columnLocation] = columnNamesOfType[lastIndex];
 01689            Array.Resize(ref columnNamesOfType, lastIndex);
 1690
 01691            int columnOrder = ColumnIDToSortOrderMap[columnID];
 1692
 01693            ref int[] denseIndicesOfType = ref ColumnDenseIndexToIDMap[(int)typeIndex].TArray;
 01694            int sparseIndexToSwap = denseIndicesOfType[lastIndex];
 1695
 01696            ColumnIDToDenseIndexMap[sparseIndexToSwap].ColumnDenseIndex = columnLocation;
 01697            ref ColumnEntry sparseIndexToFree = ref ColumnIDToDenseIndexMap[columnID];
 01698            sparseIndexToFree.ColumnType = Serializable.SerializableTypes.Invalid;
 01699            sparseIndexToFree.ColumnDenseIndex = ColumnEntriesFreeListHead;
 1700
 01701            ColumnEntriesFreeListHead = columnID;
 1702
 01703            denseIndicesOfType[columnLocation] = sparseIndexToSwap;
 01704            Array.Resize(ref denseIndicesOfType, lastIndex);
 1705
 01706            if (typeIndex == Serializable.SerializableTypes.Object)
 01707            {
 01708                RemoveTypeNameEntryForUnityObjectColumn(columnLocation);
 01709            }
 1710
 01711            for (int i = columnOrder + 1; i < CombinedColumnCount; i++)
 01712            {
 01713                int currentColumnID = SortedOrderToColumnIDMap[i];
 01714                SortedOrderToColumnIDMap[i - 1] = currentColumnID;
 01715                ColumnIDToSortOrderMap[currentColumnID] = i - 1;
 01716            }
 1717
 01718            ColumnIDToSortOrderMap[columnID] = -1;
 1719
 01720            Array.Resize(ref SortedOrderToColumnIDMap, CombinedColumnCount - 1);
 1721
 01722            --CombinedColumnCount;
 01723            DataVersion++;
 01724        }
 1725
 1726        internal void InsertRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int insertAt,
 1727            int numberOfNewRows)
 01728        {
 01729            int columnCount = allColumnsOfType?.Length ?? 0;
 01730            for (int i = 0; i < columnCount; i++)
 01731            {
 01732                ref T[] rows = ref allColumnsOfType[i].TArray;
 01733                int newRowCount = RowCount + numberOfNewRows;
 01734                Array.Resize(ref rows, newRowCount);
 01735                for (int j = newRowCount - 1; j > insertAt + numberOfNewRows - 1; j--)
 01736                {
 01737                    rows[j] = rows[j - numberOfNewRows];
 01738                }
 1739
 01740                for (int j = 0; j < numberOfNewRows; j++)
 01741                {
 01742                    rows[insertAt + j] = default;
 01743                }
 01744            }
 01745        }
 1746
 1747        internal void DeleteRowsOfTypeInternal<T>(ref ArrayHolder<T>[] allColumnsOfType, int removeAt,
 1748            int numberOfRowsToDelete)
 01749        {
 01750            int columnCount = allColumnsOfType?.Length ?? 0;
 1751
 01752            for (int i = 0; i < columnCount; i++)
 01753            {
 01754                ref T[] rows = ref allColumnsOfType[i].TArray;
 01755                int newRowCount = RowCount - numberOfRowsToDelete;
 1756
 01757                for (int j = removeAt + numberOfRowsToDelete; j < RowCount; j++)
 01758                {
 01759                    rows[j - numberOfRowsToDelete] = rows[j];
 01760                }
 1761
 01762                Array.Resize(ref rows, newRowCount);
 01763            }
 01764        }
 1765
 1766        internal ref T GetCellRef<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01767        {
 01768            AssertColumnIDValid(columnID);
 01769            AssertRowIDValid(rowID);
 01770            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01771            int row = RowIDToDenseIndexMap[rowID];
 01772            return ref allColumnsOfType[column][row];
 01773        }
 1774
 1775        internal T GetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01776        {
 01777            AssertColumnIDValid(columnID);
 01778            AssertRowIDValid(rowID);
 01779            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01780            int row = RowIDToDenseIndexMap[rowID];
 01781            return allColumnsOfType[column][row];
 01782        }
 1783
 1784        internal ulong SetCell<T>(int rowID, int columnID, ref ArrayHolder<T>[] allColumnsOfType, T value)
 01785        {
 01786            AssertColumnIDValid(columnID);
 01787            AssertRowIDValid(rowID);
 01788            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01789            int row = RowIDToDenseIndexMap[rowID];
 01790            allColumnsOfType[column][row] = value;
 01791            DataVersion++;
 01792            return DataVersion;
 01793        }
 1794
 1795        internal T[] GetColumn<T>(int columnID, ref ArrayHolder<T>[] allColumnsOfType)
 01796        {
 01797            AssertColumnIDValid(columnID);
 01798            int column = ColumnIDToDenseIndexMap[columnID].ColumnDenseIndex;
 01799            return allColumnsOfType[column].TArray;
 01800        }
 1801
 1802        internal void SetRowOrderForColumns<T>(ArrayHolder<T>[] columns, int oldSortOrder, int newSortOrder)
 01803        {
 01804            int columnCount = columns?.Length ?? 0;
 01805            int iterDirection = newSortOrder > oldSortOrder ? 1 : -1;
 01806            for (int i = 0; i < columnCount; i++)
 01807            {
 01808                T[] column = columns[i].TArray;
 1809
 01810                for (int j = oldSortOrder; j != newSortOrder; j += iterDirection)
 01811                {
 01812                    column[j] = column[j + iterDirection];
 01813                }
 01814            }
 01815        }
 1816
 1817        internal void AssertSortedColumnsArgValid(int[] sortedColumnIDs)
 01818        {
 01819            if (sortedColumnIDs == null)
 01820            {
 01821                throw new ArgumentException("sortedColumnIDs array cannot be null.");
 1822            }
 1823
 01824            if (sortedColumnIDs.Length != SortedOrderToColumnIDMap.Length)
 01825            {
 01826                throw new ArgumentException("sortedColumnIDs array must be the same length as GetColumnCount.");
 1827            }
 1828
 01829            for (int i = 0; i < sortedColumnIDs.Length; i++)
 01830            {
 01831                AssertColumnIDValid(sortedColumnIDs[i]);
 01832            }
 01833        }
 1834
 1835        internal void AssertColumnSortOrderValid(int sortedOrder)
 01836        {
 01837            if (sortedOrder >= CombinedColumnCount || sortedOrder < 0)
 01838            {
 01839                throw new ArgumentException("Invalid column sort order argument: " + sortedOrder);
 1840            }
 01841        }
 1842
 1843        internal void AssertRowSortOrderValid(int sortedOrder)
 01844        {
 01845            if (sortedOrder >= RowCount || sortedOrder < 0)
 01846            {
 01847                throw new ArgumentException("Invalid row sort order argument: " + sortedOrder);
 1848            }
 01849        }
 1850
 1851        internal void AssertSortRowsArgValid(int[] sortedRowIDs)
 01852        {
 01853            if (sortedRowIDs == null)
 01854            {
 01855                throw new ArgumentException("sortedRowIDs array cannot be null.");
 1856            }
 1857
 01858            if (sortedRowIDs.Length != RowDenseIndexToIDMap.Length)
 01859            {
 01860                throw new ArgumentException("sortedRowIDs array must be the same length as GetRowCount.");
 1861            }
 1862
 01863            for (int i = 0; i < sortedRowIDs.Length; i++)
 01864            {
 01865                AssertRowIDValid(sortedRowIDs[i]);
 01866            }
 01867        }
 1868
 1869        [Serializable]
 1870        internal struct ColumnEntry
 1871        {
 1872            public Serializable.SerializableTypes ColumnType;
 1873            public int ColumnDenseIndex;
 1874        }
 1875    }
 1876}

Coverage by test methods





































































































































































































































































































































































































































































































































































































































































































Methods/Properties

StableTable()
StableTable()
GetDataVersion()
GetColumnCount()
GetRowCount()
GetDisplayName()
SetDisplayName(System.String)
GetFlag(GDX.Tables.TableBase/Flags)
SetFlag(GDX.Tables.TableBase/Flags, System.Boolean)
GetAllRowDescriptions()
GetRowDescription(System.String)
GetRowDescription(System.Int32)
SetAllRowDescriptionsOrder(GDX.Tables.TableBase/RowDescription[])
GetColumnDescription(System.String)
GetColumnDescription(System.Int32)
SetAllColumnDescriptionsOrder(GDX.Tables.TableBase/ColumnDescription[])
GetAllColumnDescriptions()
AssertColumnIDValid(System.Int32)
AssertRowIDValid(System.Int32)
SetColumnName(System.String, System.Int32)
GetColumnName(System.Int32)
SetRowName(System.String, System.Int32)
GetRowName(System.Int32)
GetRowNameRef(System.Int32)
GetColumnNameRef(System.Int32)
AddRow(System.String, System.Int32)
AddRows(System.Int32, System.String[], System.Int32)
AddRows(System.Int32, System.Int32[]&, System.String[], System.Int32)
RemoveRow(System.Int32)
AddColumn(GDX.Serializable/SerializableTypes, System.String, System.Int32)
RemoveColumn(GDX.Serializable/SerializableTypes, System.Int32)
SetString(System.Int32, System.Int32, System.String)
SetBool(System.Int32, System.Int32, System.Boolean)
SetChar(System.Int32, System.Int32, System.Char)
SetSByte(System.Int32, System.Int32, System.SByte)
SetByte(System.Int32, System.Int32, System.Byte)
SetShort(System.Int32, System.Int32, System.Int16)
SetUShort(System.Int32, System.Int32, System.UInt16)
SetInt(System.Int32, System.Int32, System.Int32)
SetUInt(System.Int32, System.Int32, System.UInt32)
SetLong(System.Int32, System.Int32, System.Int64)
SetULong(System.Int32, System.Int32, System.UInt64)
SetFloat(System.Int32, System.Int32, System.Single)
SetDouble(System.Int32, System.Int32, System.Double)
SetVector2(System.Int32, System.Int32, UnityEngine.Vector2)
SetVector3(System.Int32, System.Int32, UnityEngine.Vector3)
SetVector4(System.Int32, System.Int32, UnityEngine.Vector4)
SetVector2Int(System.Int32, System.Int32, UnityEngine.Vector2Int)
SetVector3Int(System.Int32, System.Int32, UnityEngine.Vector3Int)
SetQuaternion(System.Int32, System.Int32, UnityEngine.Quaternion)
SetRect(System.Int32, System.Int32, UnityEngine.Rect)
SetRectInt(System.Int32, System.Int32, UnityEngine.RectInt)
SetColor(System.Int32, System.Int32, UnityEngine.Color)
SetLayerMask(System.Int32, System.Int32, UnityEngine.LayerMask)
SetBounds(System.Int32, System.Int32, UnityEngine.Bounds)
SetBoundsInt(System.Int32, System.Int32, UnityEngine.BoundsInt)
SetHash128(System.Int32, System.Int32, UnityEngine.Hash128)
SetGradient(System.Int32, System.Int32, UnityEngine.Gradient)
SetAnimationCurve(System.Int32, System.Int32, UnityEngine.AnimationCurve)
SetObject(System.Int32, System.Int32, UnityEngine.Object)
SetTypeNameForObjectColumn(System.Int32, System.String)
GetTypeNameForObjectColumn(System.Int32)
GetString(System.Int32, System.Int32)
GetBool(System.Int32, System.Int32)
GetChar(System.Int32, System.Int32)
GetSByte(System.Int32, System.Int32)
GetByte(System.Int32, System.Int32)
GetShort(System.Int32, System.Int32)
GetUShort(System.Int32, System.Int32)
GetInt(System.Int32, System.Int32)
GetUInt(System.Int32, System.Int32)
GetLong(System.Int32, System.Int32)
GetULong(System.Int32, System.Int32)
GetFloat(System.Int32, System.Int32)
GetDouble(System.Int32, System.Int32)
GetVector2(System.Int32, System.Int32)
GetVector3(System.Int32, System.Int32)
GetVector4(System.Int32, System.Int32)
GetVector2Int(System.Int32, System.Int32)
GetVector3Int(System.Int32, System.Int32)
GetQuaternion(System.Int32, System.Int32)
GetRect(System.Int32, System.Int32)
GetRectInt(System.Int32, System.Int32)
GetColor(System.Int32, System.Int32)
GetLayerMask(System.Int32, System.Int32)
GetBounds(System.Int32, System.Int32)
GetBoundsInt(System.Int32, System.Int32)
GetHash128(System.Int32, System.Int32)
GetGradient(System.Int32, System.Int32)
GetAnimationCurve(System.Int32, System.Int32)
GetObject(System.Int32, System.Int32)
GetStringRef(System.Int32, System.Int32)
GetBoolRef(System.Int32, System.Int32)
GetCharRef(System.Int32, System.Int32)
GetSbyteRef(System.Int32, System.Int32)
GetByteRef(System.Int32, System.Int32)
GetShortRef(System.Int32, System.Int32)
GetUshortRef(System.Int32, System.Int32)
GetIntRef(System.Int32, System.Int32)
GetUintRef(System.Int32, System.Int32)
GetLongRef(System.Int32, System.Int32)
GetUlongRef(System.Int32, System.Int32)
GetFloatRef(System.Int32, System.Int32)
GetDoubleRef(System.Int32, System.Int32)
GetVector2Ref(System.Int32, System.Int32)
GetVector3Ref(System.Int32, System.Int32)
GetVector4Ref(System.Int32, System.Int32)
GetVector2IntRef(System.Int32, System.Int32)
GetVector3IntRef(System.Int32, System.Int32)
GetQuaternionRef(System.Int32, System.Int32)
GetRectRef(System.Int32, System.Int32)
GetRectIntRef(System.Int32, System.Int32)
GetColorRef(System.Int32, System.Int32)
GetLayerMaskRef(System.Int32, System.Int32)
GetBoundsRef(System.Int32, System.Int32)
GetBoundsIntRef(System.Int32, System.Int32)
GetHash128Ref(System.Int32, System.Int32)
GetGradientRef(System.Int32, System.Int32)
GetAnimationCurveRef(System.Int32, System.Int32)
GetObjectRef(System.Int32, System.Int32)
GetStringColumn(System.Int32)
GetBoolColumn(System.Int32)
GetCharColumn(System.Int32)
GetSbyteColumn(System.Int32)
GetByteColumn(System.Int32)
GetShortColumn(System.Int32)
GetUshortColumn(System.Int32)
GetIntColumn(System.Int32)
GetUintColumn(System.Int32)
GetLongColumn(System.Int32)
GetUlongColumn(System.Int32)
GetFloatColumn(System.Int32)
GetDoubleColumn(System.Int32)
GetVector2Column(System.Int32)
GetVector3Column(System.Int32)
GetVector4Column(System.Int32)
GetVector2IntColumn(System.Int32)
GetVector3IntColumn(System.Int32)
GetQuaternionColumn(System.Int32)
GetRectColumn(System.Int32)
GetRectIntColumn(System.Int32)
GetColorColumn(System.Int32)
GetLayerMaskColumn(System.Int32)
GetBoundsColumn(System.Int32)
GetBoundsIntColumn(System.Int32)
GetHash128Column(System.Int32)
GetGradientColumn(System.Int32)
GetAnimationCurveColumn(System.Int32)
GetObjectColumn(System.Int32)
SetColumnOrder(System.Int32, System.Int32)
SetAllColumnOrders(System.Int32[])
SetRowOrder(System.Int32, System.Int32)
SetAllRowOrders(System.Int32[])
ReSortRows[T](, System.Int32[])
AddTypeNameEntryForUnityObjectColumn()
RemoveTypeNameEntryForUnityObjectColumn(System.Int32)
AssertObjectColumnIDValid(System.Int32)
AddColumnInternal[T](System.String, , GDX.Serializable/SerializableTypes, System.Int32)
RemoveColumnInternal[T](, GDX.Serializable/SerializableTypes, System.Int32)
InsertRowsOfTypeInternal[T](, System.Int32, System.Int32)
DeleteRowsOfTypeInternal[T](, System.Int32, System.Int32)
GetCellRef[T](System.Int32, System.Int32, )
GetCell[T](System.Int32, System.Int32, )
SetCell[T](System.Int32, System.Int32, , T)
GetColumn[T](System.Int32, )
SetRowOrderForColumns[T](, System.Int32, System.Int32)
AssertSortedColumnsArgValid(System.Int32[])
AssertColumnSortOrderValid(System.Int32)
AssertRowSortOrderValid(System.Int32)
AssertSortRowsArgValid(System.Int32[])